﻿using DesignPattern.Models;

namespace DesignPattern.Services
{
    /// <summary>
    /// 设计模式服务，提供设计模式数据
    /// </summary>
    public class DesignPatternService
    {
        private readonly List<DesignPatternModel> _patterns;

        public DesignPatternService()
        {
            _patterns = InitializePatterns();
        }

        /// <summary>
        /// 获取所有设计模式
        /// </summary>
        public IEnumerable<DesignPatternModel> GetAllPatterns()
        {
            return _patterns;
        }

        /// <summary>
        /// 根据类型获取设计模式合集
        /// </summary>
        public IEnumerable<DesignPatternModel> GetPatternsByType(PatternType type)
        {
            return _patterns.Where(p => p.Type == type);
        }

        /// <summary>
        /// 根据名称获取某个设计模式
        /// </summary>
        public DesignPatternModel? GetPatternByName(string name)
        {
            return _patterns.FirstOrDefault(p => p.Name == name);
        }

        /// <summary>
        /// 初始化设计模式数据
        /// </summary>
        private List<DesignPatternModel> InitializePatterns()
        {
            var patterns = new List<DesignPatternModel>();

            // 创建型模式
            patterns.Add(new DesignPatternModel
            {
                Name = "单例模式",
                Type = PatternType.Creational,
                Description = "🔒 确保一个类中只有一个实例，并提供一个全局访问点。单例模式是最简单的设计模式之一，但使用场景广泛。它通过将构造函数私有化，并提供一个静态方法返回唯一实例来实现。在多线程环境下需要特别注意线程安全问题，可以使用双重检查锁定或静态初始化器确保安全性。",
                UseCases = "适用于需要全局唯一实例的场景，如日志记录器、配置管理器等。",
                CodeExample = @"/// <summary>
/// 单例模式示例
/// </summary>
public sealed class Singleton
{
    // 延迟初始化的实例
    private static readonly Lazy<Singleton> _instance =
        new Lazy<Singleton>(() => new Singleton());

    // 私有构造函数，防止外部实例化
    private Singleton() { }

    // 公共访问点
    public static Singleton Instance => _instance.Value;

    // 示例方法
    public void DoSomething()
    {
        Console.WriteLine(""单例实例执行操作"");
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "工厂方法模式",
                Type = PatternType.Creational,
                Description = "🏭 定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。这是一种强大的创建型模式，它通过将对象创建逻辑封装在工厂方法中，可以使系统更加灵活。客户端只需要知道抽象产品的接口，而不需要关心具体产品的创建过程，从而使客户端代码与具体产品解耦。",
                UseCases = "适用于不知道使用者需要创建什么对象的情况，或者希望系统能够独立于它所创建的对象时。",
                CodeExample = @"/// <summary>
/// 产品接口
/// </summary>
public interface IProduct
{
    void Operation();
}

/// <summary>
/// 具体产品A
/// </summary>
public class ConcreteProductA : IProduct
{
    public void Operation()
    {
        Console.WriteLine(""ConcreteProductA 执行操作"");
    }
}

/// <summary>
/// 具体产品B
/// </summary>
public class ConcreteProductB : IProduct
{
    public void Operation()
    {
        Console.WriteLine(""ConcreteProductB 执行操作"");
    }
}

/// <summary>
/// 创建者抽象类
/// </summary>
public abstract class Creator
{
    // 工厂方法
    public abstract IProduct FactoryMethod();

    // 使用产品的方法
    public void AnOperation()
    {
        // 调用工厂方法创建产品
        IProduct product = FactoryMethod();
        product.Operation();
    }
}

/// <summary>
/// 具体创建者A，创建具体产品A
/// </summary>
public class ConcreteCreatorA : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ConcreteProductA();
    }
}

/// <summary>
/// 具体创建者B，创建具体产品B
/// </summary>
public class ConcreteCreatorB : Creator
{
    public override IProduct FactoryMethod()
    {
        return new ConcreteProductB();
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "抽象工厂模式",
                Type = PatternType.Creational,
                Description = "🏗️ 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂是工厂方法模式的扩展，它不只是创建一种产品，而是创建一族产品。这种模式尤其适合需要确保产品之间相互匹配的场景，例如不同风格的UI组件或不同数据库的访问组件。抽象工厂通过组合多个相关的工厂方法来实现复杂对象族的创建。",
                UseCases = "适用于需要创建一组相关对象的场景，如不同风格的UI组件、不同数据库的连接器等。",
                CodeExample = @"/// <summary>
/// 抽象产品A
/// </summary>
public interface IProductA
{
    void OperationA();
}

/// <summary>
/// 抽象产品B
/// </summary>
public interface IProductB
{
    void OperationB();
}

/// <summary>
/// 具体产品A1
/// </summary>
public class ConcreteProductA1 : IProductA
{
    public void OperationA()
    {
        Console.WriteLine(""ConcreteProductA1 执行操作A"");
    }
}

/// <summary>
/// 具体产品A2
/// </summary>
public class ConcreteProductA2 : IProductA
{
    public void OperationA()
    {
        Console.WriteLine(""ConcreteProductA2 执行操作A"");
    }
}

/// <summary>
/// 具体产品B1
/// </summary>
public class ConcreteProductB1 : IProductB
{
    public void OperationB()
    {
        Console.WriteLine(""ConcreteProductB1 执行操作B"");
    }
}

/// <summary>
/// 具体产品B2
/// </summary>
public class ConcreteProductB2 : IProductB
{
    public void OperationB()
    {
        Console.WriteLine(""ConcreteProductB2 执行操作B"");
    }
}

/// <summary>
/// 抽象工厂接口
/// </summary>
public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

/// <summary>
/// 具体工厂1，创建产品族1
/// </summary>
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

/// <summary>
/// 具体工厂2，创建产品族2
/// </summary>
public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "建造者模式",
                Type = PatternType.Creational,
                Description = "🛠️ 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式特别适用于构建过程复杂的对象，它通过将构建过程分解为多个步骤，并由指挥者协调这些步骤，使得构建过程更加清晰。与工厂模式不同，建造者模式更关注于对象构建过程的细节控制，而非简单的对象创建。",
                UseCases = "适用于创建复杂对象，特别是当对象需要多个步骤构建或有多种可能的表示形式时。",
                CodeExample = @"/// <summary>
/// 产品类
/// </summary>
public class Product
{
    private List<string> _parts = new List<string>();

    public void Add(string part)
    {
        _parts.Add(part);
    }

    public string ListParts()
    {
        return string.Join("", "", _parts);
    }
}

/// <summary>
/// 生成器接口
/// </summary>
public interface IBuilder
{
    void BuildPartA();
    void BuildPartB();
    void BuildPartC();
    Product GetResult();
}

/// <summary>
/// 具体生成器
/// </summary>
public class ConcreteBuilder : IBuilder
{
    private Product _product = new Product();

    public ConcreteBuilder()
    {
        Reset();
    }

    public void Reset()
    {
        _product = new Product();
    }

    public void BuildPartA()
    {
        _product.Add(""PartA"");
    }

    public void BuildPartB()
    {
        _product.Add(""PartB"");
    }

    public void BuildPartC()
    {
        _product.Add(""PartC"");
    }

    public Product GetResult()
    {
        Product result = _product;
        Reset();
        return result;
    }
}

/// <summary>
/// 指挥者
/// </summary>
public class Director
{
    private IBuilder _builder;

    public Director(IBuilder builder)
    {
        _builder = builder;
    }

    public void SetBuilder(IBuilder builder)
    {
        _builder = builder;
    }

    // 构建最小可用产品
    public void BuildMinimalViableProduct()
    {
        _builder.BuildPartA();
    }

    // 构建完整产品
    public void BuildFullFeaturedProduct()
    {
        _builder.BuildPartA();
        _builder.BuildPartB();
        _builder.BuildPartC();
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "原型模式",
                Type = PatternType.Creational,
                Description = "🧬 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式避免了重复创建对象的昂贵过程，特别是当对象创建成本高或初始化需要大量资源时。它通过复制现有对象生成新对象，而不是使用新建构造函数。在实现上需要注意浅拷贝和深拷贝的区别，以及处理对象间的循环引用问题。",
                UseCases = "适用于需要创建大量相似对象的场景，特别是当对象创建成本较高时。",
                CodeExample = @"/// <summary>
/// 原型接口
/// </summary>
public interface IPrototype
{
    IPrototype Clone();
}

/// <summary>
/// 具体原型
/// </summary>
public class ConcretePrototype : IPrototype
{
    public string Property { get; set; }

    public ConcretePrototype(string property)
    {
        Property = property;
    }

    // 创建当前对象的浅表副本
    public IPrototype Clone()
    {
        return new ConcretePrototype(Property);
    }
}

/// <summary>
/// 使用示例
/// </summary>
public class PrototypeExample
{
    public static void Run()
    {
        ConcretePrototype prototype = new ConcretePrototype(""原始值"");
        
        // 通过克隆创建新对象
        ConcretePrototype clone = (ConcretePrototype)prototype.Clone();
        
        // 修改克隆对象的属性
        clone.Property = ""修改后的值"";
        
        Console.WriteLine($""原型: {prototype.Property}"");
        Console.WriteLine($""克隆: {clone.Property}"");
    }
}

/// <summary>
/// 包含深拷贝的复杂原型
/// </summary>
public class ComplexPrototype : IPrototype
{
    public string SimpleProp { get; set; }
    public List<string> ComplexProp { get; set; }

    public ComplexPrototype(string simpleProp, List<string> complexProp)
    {
        SimpleProp = simpleProp;
        ComplexProp = complexProp;
    }

    // 深拷贝
    public IPrototype Clone()
    {
        var newComplexProp = new List<string>(ComplexProp);
        return new ComplexPrototype(SimpleProp, newComplexProp);
    }
}"
            });

            // 结构型模式
            patterns.Add(new DesignPatternModel
            {
                Name = "适配器模式",
                Type = PatternType.Structural,
                Description = "🔌 将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。适配器模式有两种实现方式：对象适配器(通过组合)和类适配器(通过继承)。这种模式特别适合于集成第三方库或遗留系统，使它们能够与现有系统协同工作，而无需修改原有代码。",
                UseCases = "适用于需要使用现有类，但其接口不符合需求的情况。",
                CodeExample = @"/// <summary>
/// 目标接口
/// </summary>
public interface ITarget
{
    void Request();
}

/// <summary>
/// 需要适配的类
/// </summary>
public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine(""Adaptee的特殊请求"");
    }
}

/// <summary>
/// 对象适配器
/// </summary>
public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request()
    {
        // 调用adaptee的方法
        _adaptee.SpecificRequest();
    }
}

/// <summary>
/// 类适配器（使用继承）
/// </summary>
public class ClassAdapter : Adaptee, ITarget
{
    public void Request()
    {
        // 调用父类的方法
        SpecificRequest();
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "装饰器模式",
                Type = PatternType.Structural,
                Description = "🎀 动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式比生成子类更为灵活。装饰器模式通过将对象包装在装饰器类的对象中，从而在运行时动态地添加功能，而不需要修改原始对象。这种模式特别适合于在不破坏原有类结构的情况下，灵活地扩展对象功能。装饰器模式遵循开闭原则，允许系统在不修改现有代码的情况下引入新功能。",
                UseCases = "适用于需要透明且动态地扩展对象功能的场景，如I/O流、UI组件等。",
                CodeExample = @"/// <summary>
/// 组件接口
/// </summary>
public interface IComponent
{
    string Operation();
}

/// <summary>
/// 具体组件
/// </summary>
public class ConcreteComponent : IComponent
{
    public string Operation()
    {
        return ""ConcreteComponent"";
    }
}

/// <summary>
/// 装饰器抽象类
/// </summary>
public abstract class Decorator : IComponent
{
    protected IComponent _component;

    public Decorator(IComponent component)
    {
        _component = component;
    }

    // 默认将操作转发给组件
    public virtual string Operation()
    {
        return _component.Operation();
    }
}

/// <summary>
/// 具体装饰器A
/// </summary>
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component)
    {
    }

    public override string Operation()
    {
        return $""ConcreteDecoratorA({base.Operation()})"";
    }
}

/// <summary>
/// 具体装饰器B
/// </summary>
public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component)
    {
    }

    public override string Operation()
    {
        return $""ConcreteDecoratorB({base.Operation()})"";
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "桥接模式",
                Type = PatternType.Structural,
                Description = "🌉 将抽象部分与它的实现部分分离，使它们都可以独立地变化。桥接模式通过将一个对象的两个维度（抽象和实现）分离，并各自封装，使它们可以独立地变化。这种模式特别适合于处理多维度变化的系统，它可以避免由于维度组合爆炸而导致的类数量激增问题。桥接模式使得系统更加灵活，易于扩展。",
                UseCases = "适用于需要将抽象和实现解耦，或者需要在运行时切换实现的场景。",
                CodeExample = @"/// <summary>
/// 实现接口
/// </summary>
public interface IImplementation
{
    string OperationImplementation();
}

/// <summary>
/// 具体实现A
/// </summary>
public class ConcreteImplementationA : IImplementation
{
    public string OperationImplementation()
    {
        return ""ConcreteImplementationA 的结果"";
    }
}

/// <summary>
/// 具体实现B
/// </summary>
public class ConcreteImplementationB : IImplementation
{
    public string OperationImplementation()
    {
        return ""ConcreteImplementationB 的结果"";
    }
}

/// <summary>
/// 抽象部分
/// </summary>
public abstract class Abstraction
{
    protected IImplementation _implementation;

    public Abstraction(IImplementation implementation)
    {
        _implementation = implementation;
    }

    public virtual string Operation()
    {
        return _implementation.OperationImplementation();
    }
}

/// <summary>
/// 扩展的抽象部分
/// </summary>
public class ExtendedAbstraction : Abstraction
{
    public ExtendedAbstraction(IImplementation implementation) : base(implementation)
    {
    }

    public override string Operation()
    {
        return $""扩展操作，使用: {base.Operation()}"";
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "组合模式",
                Type = PatternType.Structural,
                Description = "🌲 将对象组合成树形结构以表示'部分-整体'的层次结构，使得用户对单个对象和组合对象的使用具有一致性。组合模式允许客户端统一处理单个对象和对象组合，而不需要区分它们。这种模式特别适合于表示树形结构的数据，如文件系统、组织结构等。它使得客户端代码可以以一致的方式处理复杂的层次结构。",
                UseCases = "适用于需要处理树形结构中的对象，如文件系统、图形界面组件等。",
                CodeExample = @"/// <summary>
/// 组件接口
/// </summary>
public interface IComponent
{
    string Operation();
    void Add(IComponent component);
    void Remove(IComponent component);
    IComponent GetChild(int index);
}

/// <summary>
/// 叶子节点
/// </summary>
public class Leaf : IComponent
{
    private string _name;

    public Leaf(string name)
    {
        _name = name;
    }

    public string Operation()
    {
        return $""Leaf {_name} 操作"";
    }

    // 叶子节点没有子节点，这些方法可以抛出异常或做空实现
    public void Add(IComponent component)
    {
        throw new NotImplementedException(""叶子节点不能添加子节点"");
    }

    public void Remove(IComponent component)
    {
        throw new NotImplementedException(""叶子节点不能移除子节点"");
    }

    public IComponent GetChild(int index)
    {
        throw new NotImplementedException(""叶子节点没有子节点"");
    }
}

/// <summary>
/// 复合节点
/// </summary>
public class Composite : IComponent
{
    private string _name;
    private List<IComponent> _children = new List<IComponent>();

    public Composite(string name)
    {
        _name = name;
    }

    public string Operation()
    {
        string result = $""Composite {_name} 操作\\n"";
        
        foreach (var child in _children)
        {
            result += child.Operation() + ""\\n"";
        }
        
        return result;
    }

    public void Add(IComponent component)
    {
        _children.Add(component);
    }

    public void Remove(IComponent component)
    {
        _children.Remove(component);
    }

    public IComponent GetChild(int index)
    {
        if (index >= 0 && index < _children.Count)
        {
            return _children[index];
        }
        
        return null;
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "外观模式",
                Type = PatternType.Structural,
                Description = "🏢 为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。外观模式通过创建一个简单的接口来隐藏系统的复杂性，为客户端提供一个简单的访问点。这种模式特别适合于简化复杂系统的使用，降低客户端与子系统的耦合度，同时也可以作为子系统的入口点，控制对子系统的访问。",
                UseCases = "适用于需要简化复杂子系统的使用，或者需要将子系统与客户端解耦的场景。",
                CodeExample = @"/// <summary>
/// 子系统1
/// </summary>
public class SubsystemOne
{
    public string OperationOne()
    {
        return ""子系统1操作"";
    }
}

/// <summary>
/// 子系统2
/// </summary>
public class SubsystemTwo
{
    public string OperationTwo()
    {
        return ""子系统2操作"";
    }
}

/// <summary>
/// 子系统3
/// </summary>
public class SubsystemThree
{
    public string OperationThree()
    {
        return ""子系统3操作"";
    }
}

/// <summary>
/// 外观类
/// </summary>
public class Facade
{
    private SubsystemOne _one;
    private SubsystemTwo _two;
    private SubsystemThree _three;

    public Facade()
    {
        _one = new SubsystemOne();
        _two = new SubsystemTwo();
        _three = new SubsystemThree();
    }

    // 提供一个简单的接口
    public string Operation()
    {
        string result = ""外观初始化子系统:\\n"";
        result += _one.OperationOne() + ""\\n"";
        result += _two.OperationTwo() + ""\\n"";
        result += _three.OperationThree() + ""\\n"";
        return result;
    }
}"
            });

            // 行为型模式
            patterns.Add(new DesignPatternModel
            {
                Name = "观察者模式",
                Type = PatternType.Behavioral,
                Description = "👀 定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。观察者模式是一种常用的发布-订阅模式，它使得对象之间的通信更加灵活。主题（被观察者）维护一个观察者列表，当主题状态改变时，它会通知所有观察者。这种模式广泛应用于事件处理系统、用户界面更新、数据同步等场景。",
                UseCases = "适用于当一个对象的改变需要同时改变其他对象，而且不知道具体有多少对象需要改变的情况。",
                CodeExample = @"/// <summary>
/// 观察者接口
/// </summary>
public interface IObserver
{
    void Update(string message);
}

/// <summary>
/// 主题接口
/// </summary>
public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

/// <summary>
/// 具体主题
/// </summary>
public class ConcreteSubject : ISubject
{
    private readonly List<IObserver> _observers = new List<IObserver>();
    private string _state;

    public string State
    {
        get => _state;
        set
        {
            _state = value;
            Notify();
        }
    }

    public void Attach(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        _observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in _observers)
        {
            observer.Update(_state);
        }
    }
}

/// <summary>
/// 具体观察者
/// </summary>
public class ConcreteObserver : IObserver
{
    private readonly string _name;

    public ConcreteObserver(string name)
    {
        _name = name;
    }

    public void Update(string message)
    {
        Console.WriteLine($""观察者 {_name} 收到通知: {message}"");
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "策略模式",
                Type = PatternType.Behavioral,
                Description = "🎯 定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。策略模式让算法独立于使用它的客户而变化。策略模式将算法的定义与使用分离，允许在运行时选择不同的算法。它通过将算法封装在独立的策略类中，并提供统一的接口使得它们可以互相替换。这种模式特别适合于处理一组相关但不同的算法，如不同的排序算法、压缩算法等。",
                UseCases = "适用于需要在运行时选择不同算法的场景，如排序算法、验证策略等。",
                CodeExample = @"/// <summary>
/// 策略接口
/// </summary>
public interface IStrategy
{
    int DoOperation(int num1, int num2);
}

/// <summary>
/// 具体策略A - 加法
/// </summary>
public class AddStrategy : IStrategy
{
    public int DoOperation(int num1, int num2)
    {
        return num1 + num2;
    }
}

/// <summary>
/// 具体策略B - 减法
/// </summary>
public class SubtractStrategy : IStrategy
{
    public int DoOperation(int num1, int num2)
    {
        return num1 - num2;
    }
}

/// <summary>
/// 具体策略C - 乘法
/// </summary>
public class MultiplyStrategy : IStrategy
{
    public int DoOperation(int num1, int num2)
    {
        return num1 * num2;
    }
}

/// <summary>
/// 上下文
/// </summary>
public class Context
{
    private IStrategy _strategy;

    public Context(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public void SetStrategy(IStrategy strategy)
    {
        _strategy = strategy;
    }

    public int ExecuteStrategy(int num1, int num2)
    {
        return _strategy.DoOperation(num1, num2);
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "命令模式",
                Type = PatternType.Behavioral,
                Description = "🎮 将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化，对请求排队或记录请求日志，以及支持可撤销的操作。命令模式将请求发送者与接收者解耦，通过将请求封装成命令对象，可以实现请求的延迟执行、队列处理、日志记录以及撤销/重做功能。这种模式广泛应用于图形界面中的菜单命令、事务处理、宏命令等场景。",
                UseCases = "适用于需要将请求发送者与接收者解耦，或需要将请求参数化并支持撤销操作的场景。",
                CodeExample = @"/// <summary>
/// 命令接口
/// </summary>
public interface ICommand
{
    void Execute();
    void Undo();
}

/// <summary>
/// 接收者类
/// </summary>
public class Receiver
{
    public void Action()
    {
        Console.WriteLine(""执行接收者操作"");
    }

    public void UndoAction()
    {
        Console.WriteLine(""撤销接收者操作"");
    }
}

/// <summary>
/// 具体命令
/// </summary>
public class ConcreteCommand : ICommand
{
    private Receiver _receiver;

    public ConcreteCommand(Receiver receiver)
    {
        _receiver = receiver;
    }

    public void Execute()
    {
        _receiver.Action();
    }

    public void Undo()
    {
        _receiver.UndoAction();
    }
}

/// <summary>
/// 调用者
/// </summary>
public class Invoker
{
    private ICommand _command;

    public void SetCommand(ICommand command)
    {
        _command = command;
    }

    public void ExecuteCommand()
    {
        _command.Execute();
    }

    public void UndoCommand()
    {
        _command.Undo();
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "模板方法模式",
                Type = PatternType.Behavioral,
                Description = "📝 定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。模板方法模式通过在基类中定义算法的框架，并将某些步骤的具体实现延迟到子类中，实现了代码复用和扩展。基类通常包含一个模板方法，它定义了算法的步骤序列，并调用抽象方法或钩子方法，这些方法可以由子类重写以提供特定的实现。",
                UseCases = "适用于当算法的基本骨架是固定的，但具体步骤可能会有变化的场景。",
                CodeExample = @"/// <summary>
/// 抽象类，定义模板方法
/// </summary>
public abstract class AbstractClass
{
    // 模板方法，定义了算法的骨架
    public void TemplateMethod()
    {
        PrimitiveOperation1();
        PrimitiveOperation2();
        Hook();
    }

    // 由子类实现的抽象操作
    protected abstract void PrimitiveOperation1();
    protected abstract void PrimitiveOperation2();

    // 钩子方法，子类可以选择性覆盖
    protected virtual void Hook() { }
}

/// <summary>
/// 具体类A
/// </summary>
public class ConcreteClassA : AbstractClass
{
    protected override void PrimitiveOperation1()
    {
        Console.WriteLine(""ConcreteClassA: 实现操作1"");
    }

    protected override void PrimitiveOperation2()
    {
        Console.WriteLine(""ConcreteClassA: 实现操作2"");
    }
}

/// <summary>
/// 具体类B
/// </summary>
public class ConcreteClassB : AbstractClass
{
    protected override void PrimitiveOperation1()
    {
        Console.WriteLine(""ConcreteClassB: 实现操作1"");
    }

    protected override void PrimitiveOperation2()
    {
        Console.WriteLine(""ConcreteClassB: 实现操作2"");
    }

    // 覆盖钩子方法
    protected override void Hook()
    {
        Console.WriteLine(""ConcreteClassB: 覆盖钩子方法"");
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "状态模式",
                Type = PatternType.Behavioral,
                Description = "🔄 允许对象在内部状态改变时改变它的行为，对象看起来似乎修改了它的类。状态模式将对象的状态封装成独立的类，并将与状态相关的行为委托给当前状态对象。当对象的状态改变时，只需要切换到新的状态对象，而不需要使用大量的条件语句。这种模式使得代码更加清晰，易于扩展，并且避免了状态转换逻辑分散在多个方法中的问题。",
                UseCases = "适用于对象的行为依赖于它的状态，并且它必须在运行时根据状态改变它的行为的场景。",
                CodeExample = @"/// <summary>
/// 状态接口
/// </summary>
public interface IState
{
    void Handle(Context context);
}

/// <summary>
/// 具体状态A
/// </summary>
public class ConcreteStateA : IState
{
    public void Handle(Context context)
    {
        Console.WriteLine(""当前状态: A"");
        // 状态转换到B
        context.State = new ConcreteStateB();
    }
}

/// <summary>
/// 具体状态B
/// </summary>
public class ConcreteStateB : IState
{
    public void Handle(Context context)
    {
        Console.WriteLine(""当前状态: B"");
        // 状态转换到A
        context.State = new ConcreteStateA();
    }
}

/// <summary>
/// 上下文类
/// </summary>
public class Context
{
    private IState _state;

    public Context(IState state)
    {
        _state = state;
    }

    public IState State
    {
        get => _state;
        set => _state = value;
    }

    public void Request()
    {
        _state.Handle(this);
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "访问者模式",
                Type = PatternType.Behavioral,
                Description = "🧐 表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。访问者模式将数据结构与数据操作分离，通过将操作封装在访问者对象中，可以在不修改数据结构的情况下增加新的操作。这种模式特别适合于操作复杂的对象结构，如编译器中的抽象语法树、文档对象模型等。它遵循开闭原则，但需要注意的是，当需要添加新的元素类型时，所有的访问者都需要更新。",
                UseCases = "适用于对象结构中的元素有不同的类型，需要对这些元素执行不同的操作，且希望避免在各个类中添加操作的场景。",
                CodeExample = @"/// <summary>
/// 访问者接口
/// </summary>
public interface IVisitor
{
    void Visit(ConcreteElementA element);
    void Visit(ConcreteElementB element);
}

/// <summary>
/// 元素接口
/// </summary>
public interface IElement
{
    void Accept(IVisitor visitor);
}

/// <summary>
/// 具体元素A
/// </summary>
public class ConcreteElementA : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }

    public string OperationA()
    {
        return ""ElementA 操作"";
    }
}

/// <summary>
/// 具体元素B
/// </summary>
public class ConcreteElementB : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }

    public string OperationB()
    {
        return ""ElementB 操作"";
    }
}

/// <summary>
/// 具体访问者
/// </summary>
public class ConcreteVisitor : IVisitor
{
    public void Visit(ConcreteElementA element)
    {
        Console.WriteLine($""访问者对ElementA的操作: {element.OperationA()}"");
    }

    public void Visit(ConcreteElementB element)
    {
        Console.WriteLine($""访问者对ElementB的操作: {element.OperationB()}"");
    }
}

/// <summary>
/// 对象结构
/// </summary>
public class ObjectStructure
{
    private List<IElement> _elements = new List<IElement>();

    public void Attach(IElement element)
    {
        _elements.Add(element);
    }

    public void Detach(IElement element)
    {
        _elements.Remove(element);
    }

    public void Accept(IVisitor visitor)
    {
        foreach (var element in _elements)
        {
            element.Accept(visitor);
        }
    }
}"
            });

            // 添加缺少的结构型模式
            patterns.Add(new DesignPatternModel
            {
                Name = "享元模式",
                Type = PatternType.Structural,
                Description = "🔄 运用共享技术有效地支持大量细粒度的对象，减少对象的创建数量，从而减少内存占用和提高性能。享元模式通过共享相同的对象实例来减少内存使用和对象创建的开销。它区分了对象的内部状态（可共享）和外部状态（不可共享），将外部状态传递给享元对象，而不是存储在对象中。这种模式在处理大量相似对象时非常有效，如文本编辑器中的字符渲染、游戏中的粒子效果等。",
                UseCases = "适用于系统中存在大量相似对象，造成内存开销较大的场景，如文本编辑器中的字符渲染、游戏中的粒子系统等。",
                CodeExample = @"/// <summary>
/// 享元接口
/// </summary>
public interface IFlyweight
{
    void Operation(string extrinsicState);
}

/// <summary>
/// 具体享元类
/// </summary>
public class ConcreteFlyweight : IFlyweight
{
    private readonly string _intrinsicState;

    public ConcreteFlyweight(string intrinsicState)
    {
        _intrinsicState = intrinsicState;
    }

    public void Operation(string extrinsicState)
    {
        Console.WriteLine($""内部状态: {_intrinsicState}, 外部状态: {extrinsicState}"");
    }
}

/// <summary>
/// 享元工厂
/// </summary>
public class FlyweightFactory
{
    private readonly Dictionary<string, IFlyweight> _flyweights = new Dictionary<string, IFlyweight>();

    public IFlyweight GetFlyweight(string key)
    {
        // 如果对象已存在，直接返回
        if (_flyweights.ContainsKey(key))
        {
            Console.WriteLine($""复用现有享元: {key}"");
            return _flyweights[key];
        }
        
        // 否则创建新对象并存储
        Console.WriteLine($""创建新享元: {key}"");
        var flyweight = new ConcreteFlyweight(key);
        _flyweights.Add(key, flyweight);
        return flyweight;
    }

    public int FlyweightCount => _flyweights.Count;
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "代理模式",
                Type = PatternType.Structural,
                Description = "🛡️ 为其他对象提供一种代理以控制对这个对象的访问。代理对象可以在客户端和目标对象之间起到中介的作用，并且可以添加额外的功能。代理模式有多种变体，如远程代理、虚拟代理、保护代理等，它们各自解决不同的问题。代理模式可以用于延迟加载、访问控制、日志记录等场景，它通过将间接访问的复杂性封装在代理对象中，使得客户端代码更加简洁。",
                UseCases = "适用于需要控制对对象的访问、需要添加额外功能或者延迟初始化对象的场景，如远程代理、虚拟代理、保护代理等。",
                CodeExample = @"/// <summary>
/// 主题接口
/// </summary>
public interface ISubject
{
    void Request();
}

/// <summary>
/// 真实主题
/// </summary>
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine(""真实主题处理请求"");
    }
}

/// <summary>
/// 代理类
/// </summary>
public class Proxy : ISubject
{
    private RealSubject _realSubject;

    // 延迟初始化
    private RealSubject GetRealSubject()
    {
        if (_realSubject == null)
        {
            _realSubject = new RealSubject();
        }
        return _realSubject;
    }

    public void Request()
    {
        // 前置处理
        Console.WriteLine(""代理：前置处理"");
        
        // 调用真实主题的方法
        GetRealSubject().Request();
        
        // 后置处理
        Console.WriteLine(""代理：后置处理"");
    }
}

/// <summary>
/// 保护代理示例
/// </summary>
public class ProtectionProxy : ISubject
{
    private RealSubject _realSubject;
    private readonly string _password;

    public ProtectionProxy(RealSubject realSubject, string password)
    {
        _realSubject = realSubject;
        _password = password;
    }

    public void Request()
    {
        if (_password == ""admin"")
        {
            // 鉴权通过，执行请求
            _realSubject.Request();
        }
        else
        {
            Console.WriteLine(""没有访问权限"");
        }
    }
}"
            });

            // 添加缺少的行为型模式
            patterns.Add(new DesignPatternModel
            {
                Name = "责任链模式",
                Type = PatternType.Behavioral,
                Description = "⛓️ 避免将一个请求的发送者与接收者耦合在一起，让多个对象都有机会处理请求。将接收请求的对象连接成一条链，并沿着这条链传递请求直到有对象处理它为止。责任链模式通过建立对象链并沿链传递请求，直到某个对象处理它为止，实现了请求发送者与接收者的解耦。这种模式特别适合于有多个处理器可以处理同一请求，但具体由哪个处理器处理取决于运行时条件的场景。它允许动态地修改责任链，增加或删除处理器，使系统更加灵活。",
                UseCases = "适用于有多个对象可以处理同一个请求，具体由哪个对象处理由运行时决定的场景，如日志记录、请求审批、异常处理等。",
                CodeExample = @"/// <summary>
/// 处理者抽象类
/// </summary>
public abstract class Handler
{
    protected Handler _successor;

    public void SetSuccessor(Handler successor)
    {
        _successor = successor;
    }

    public abstract void HandleRequest(int request);
}

/// <summary>
/// 具体处理者A
/// </summary>
public class ConcreteHandlerA : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 0 && request < 10)
        {
            Console.WriteLine($""ConcreteHandlerA 处理请求 {request}"");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
    }
}

/// <summary>
/// 具体处理者B
/// </summary>
public class ConcreteHandlerB : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 10 && request < 20)
        {
            Console.WriteLine($""ConcreteHandlerB 处理请求 {request}"");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
    }
}

/// <summary>
/// 具体处理者C
/// </summary>
public class ConcreteHandlerC : Handler
{
    public override void HandleRequest(int request)
    {
        if (request >= 20 && request < 30)
        {
            Console.WriteLine($""ConcreteHandlerC 处理请求 {request}"");
        }
        else if (_successor != null)
        {
            _successor.HandleRequest(request);
        }
        else
        {
            Console.WriteLine($""没有处理者能处理请求 {request}"");
        }
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "迭代器模式",
                Type = PatternType.Behavioral,
                Description = "🔄 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。迭代器模式将遍历集合的责任从集合对象转移到迭代器对象，使得集合接口更加简洁，并支持多种遍历方式。迭代通过提供统一的接口访问集合元素，隐藏了集合的内部实现细节，同时还可以支持并发迭代、懒加载等高级功能。现代编程语言通常内置了迭代器支持，如C#的IEnumerable接口和foreach语句。",
                UseCases = "适用于需要遍历集合对象而不暴露其内部结构的场景，如自定义集合的遍历。",
                CodeExample = @"/// <summary>
/// 迭代器接口
/// </summary>
public interface IIterator<T>
{
    bool HasNext();
    T Next();
}

/// <summary>
/// 集合接口
/// </summary>
public interface IAggregate<T>
{
    IIterator<T> CreateIterator();
}

/// <summary>
/// 具体集合
/// </summary>
public class ConcreteAggregate<T> : IAggregate<T>
{
    private readonly List<T> _items = new List<T>();

    public void Add(T item)
    {
        _items.Add(item);
    }

    public T this[int index]
    {
        get { return _items[index]; }
    }

    public int Count
    {
        get { return _items.Count; }
    }

    public IIterator<T> CreateIterator()
    {
        return new ConcreteIterator<T>(this);
    }
}

/// <summary>
/// 具体迭代器
/// </summary>
public class ConcreteIterator<T> : IIterator<T>
{
    private readonly ConcreteAggregate<T> _aggregate;
    private int _currentIndex = 0;

    public ConcreteIterator(ConcreteAggregate<T> aggregate)
    {
        _aggregate = aggregate;
    }

    public bool HasNext()
    {
        return _currentIndex < _aggregate.Count;
    }

    public T Next()
    {
        if (!HasNext())
        {
            throw new InvalidOperationException(""没有更多元素"");
        }
        
        return _aggregate[_currentIndex++];
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "中介者模式",
                Type = PatternType.Behavioral,
                Description = "🔄 用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式通过引入一个中介者对象，集中处理对象之间的交互逻辑，降低了对象之间的直接耦合。它特别适合于对象之间交互复杂、关系网状化的系统，如图形用户界面中的控件交互、航空管制系统等。中介者模式简化了对象间的通信，但需要注意，中介者对象自身可能变得复杂。",
                UseCases = "适用于对象之间的交互复杂，存在大量的相互依赖关系，导致难以理解和维护的场景，如GUI组件交互、聊天室等。",
                CodeExample = @"/// <summary>
/// 中介者接口
/// </summary>
public interface IMediator
{
    void Send(string message, Colleague colleague);
}

/// <summary>
/// 抽象同事类
/// </summary>
public abstract class Colleague
{
    protected IMediator _mediator;

    public Colleague(IMediator mediator)
    {
        _mediator = mediator;
    }

    public abstract void Send(string message);
    public abstract void Receive(string message);
}

/// <summary>
/// 具体中介者
/// </summary>
public class ConcreteMediator : IMediator
{
    private ConcreteColleagueA _colleagueA;
    private ConcreteColleagueB _colleagueB;

    public ConcreteColleagueA ColleagueA
    {
        set { _colleagueA = value; }
    }

    public ConcreteColleagueB ColleagueB
    {
        set { _colleagueB = value; }
    }

    public void Send(string message, Colleague colleague)
    {
        if (colleague == _colleagueA)
        {
            _colleagueB.Receive(message);
        }
        else
        {
            _colleagueA.Receive(message);
        }
    }
}

/// <summary>
/// 具体同事A
/// </summary>
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(IMediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine($""同事A发送消息: {message}"");
        _mediator.Send(message, this);
    }

    public override void Receive(string message)
    {
        Console.WriteLine($""同事A收到消息: {message}"");
    }
}

/// <summary>
/// 具体同事B
/// </summary>
public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(IMediator mediator) : base(mediator) { }

    public override void Send(string message)
    {
        Console.WriteLine($""同事B发送消息: {message}"");
        _mediator.Send(message, this);
    }

    public override void Receive(string message)
    {
        Console.WriteLine($""同事B收到消息: {message}"");
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "备忘录模式",
                Type = PatternType.Behavioral,
                Description = "📸 在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。备忘录模式允许在不暴露对象实现细节的情况下保存和恢复对象状态。它通过创建一个包含状态快照的备忘录对象，并由管理者对象保管这些备忘录，实现了状态的存储和恢复。这种模式广泛应用于需要撤销/重做功能、事务回滚、快照保存等场景。",
                UseCases = "适用于需要保存和恢复对象状态的场景，如撤销/重做功能、事务回滚、快照记录等。",
                CodeExample = @"/// <summary>
/// 发起人
/// </summary>
public class Originator
{
    private string _state;

    public string State
    {
        get { return _state; }
        set
        {
            _state = value;
            Console.WriteLine($""当前状态: {_state}"");
        }
    }

    // 创建备忘录，保存当前状态
    public Memento SaveStateToMemento()
    {
        return new Memento(_state);
    }

    // 从备忘录恢复状态
    public void RestoreStateFromMemento(Memento memento)
    {
        State = memento.State;
    }
}

/// <summary>
/// 备忘录
/// </summary>
public class Memento
{
    private readonly string _state;

    public Memento(string state)
    {
        _state = state;
    }

    public string State
    {
        get { return _state; }
    }
}

/// <summary>
/// 管理者
/// </summary>
public class Caretaker
{
    private readonly List<Memento> _mementoList = new List<Memento>();

    public void Add(Memento state)
    {
        _mementoList.Add(state);
    }

    public Memento Get(int index)
    {
        return _mementoList[index];
    }
}"
            });

            patterns.Add(new DesignPatternModel
            {
                Name = "解释器模式",
                Type = PatternType.Behavioral,
                Description = "🔍 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。解释器模式用于定义语言的文法规则，并解释相应语言的表达式。它通过构建抽象语法树，使用组合模式表示文法规则，并通过递归方式解释这些规则。这种模式适用于需要解释简单语言或DSL(领域特定语言)的场景，但对于复杂语言，可能需要使用专业的解析器生成工具。",
                UseCases = "适用于需要解释特定语言或表达式的场景，如SQL解析器、正则表达式引擎、数学表达式计算等。",
                CodeExample = @"/// <summary>
/// 表达式接口
/// </summary>
public interface IExpression
{
    int Interpret(Dictionary<string, int> context);
}

/// <summary>
/// 终结符表达式
/// </summary>
public class TerminalExpression : IExpression
{
    private readonly string _variableName;

    public TerminalExpression(string variableName)
    {
        _variableName = variableName;
    }

    public int Interpret(Dictionary<string, int> context)
    {
        if (context.ContainsKey(_variableName))
        {
            return context[_variableName];
        }
        return 0;
    }
}

/// <summary>
/// 加法表达式
/// </summary>
public class AddExpression : IExpression
{
    private readonly IExpression _left;
    private readonly IExpression _right;

    public AddExpression(IExpression left, IExpression right)
    {
        _left = left;
        _right = right;
    }

    public int Interpret(Dictionary<string, int> context)
    {
        return _left.Interpret(context) + _right.Interpret(context);
    }
}

/// <summary>
/// 减法表达式
/// </summary>
public class SubtractExpression : IExpression
{
    private readonly IExpression _left;
    private readonly IExpression _right;

    public SubtractExpression(IExpression left, IExpression right)
    {
        _left = left;
        _right = right;
    }

    public int Interpret(Dictionary<string, int> context)
    {
        return _left.Interpret(context) - _right.Interpret(context);
    }
}

/// <summary>
/// 使用示例
/// </summary>
public class InterpreterExample
{
    public static IExpression Parse(string expression)
    {
        // 简单示例：仅支持单变量和简单加减法
        // a + b - c
        string[] tokens = expression.Split(' ');
        
        if (tokens.Length == 1)
        {
            return new TerminalExpression(tokens[0]);
        }
        
        IExpression left = new TerminalExpression(tokens[0]);
        
        for (int i = 1; i < tokens.Length; i += 2)
        {
            string op = tokens[i];
            string right = tokens[i + 1];
            
            if (op == ""+"")
            {
                left = new AddExpression(left, new TerminalExpression(right));
            }
            else if (op == ""-"")
            {
                left = new SubtractExpression(left, new TerminalExpression(right));
            }
        }
        
        return left;
    }
}"
            });

            return patterns;
        }
    }
}
